const express = require('express');
const router = express.Router();
const multer = require('multer');
const path = require('path');
const fs = require('fs');
const { authenticateToken } = require('../middleware/auth');
const ResponseHelper = require('../utils/response');
const LocalServicePrisma = require('../models/LocalServicePrisma');
const ServiceCategoryPrisma = require('../models/ServiceCategoryPrisma');
const UserPrisma = require('../models/UserPrisma');

// 配置multer用于本地服务图片上传
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    const uploadDir = path.join(__dirname, '../uploads/local-services');
    // 确保目录存在
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir, { recursive: true });
    }
    cb(null, uploadDir);
  },
  filename: function (req, file, cb) {
    // 生成唯一文件名
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, 'service-' + uniqueSuffix + path.extname(file.originalname));
  }
});

const upload = multer({
  storage: storage,
  limits: {
    fileSize: 5 * 1024 * 1024 // 5MB限制
  },
  fileFilter: (req, file, cb) => {
    // 允许的图片类型
    const allowedTypes = /jpeg|jpg|png|gif/;
    const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
    const mimetype = allowedTypes.test(file.mimetype);
    
    if (mimetype && extname) {
      return cb(null, true);
    } else {
      cb(new Error('只支持图片文件 (jpeg, jpg, png, gif)'));
    }
  }
});

/**
 * 上传本地服务图片
 * POST /api/v1/local-services/upload-image
 */
router.post('/upload-image', authenticateToken, upload.single('image'), async (req, res) => {
  try {
    if (!req.file) {
      return ResponseHelper.error(res, '请选择要上传的图片文件', 400);
    }

    // 构建图片URL - 从请求头中获取前端的基础地址
    const protocol = req.get('x-forwarded-proto') || req.protocol || 'http';
    const host = req.get('host');
    const baseUrl = `${protocol}://${host}`;
    const imageUrl = `${baseUrl}/uploads/local-services/${req.file.filename}`;

    ResponseHelper.success(res, { url: imageUrl }, '图片上传成功');
  } catch (error) {
    console.error('图片上传失败:', error);
    ResponseHelper.serverError(res, '图片上传失败', error);
  }
});

// 获取服务分类列表
router.get('/categories', async (req, res) => {
  try {
    const categories = await ServiceCategoryPrisma.findAllActive();
    return ResponseHelper.success(res, categories, '获取服务分类成功');
  } catch (err) {
    console.error('获取服务分类失败:', err);
    return ResponseHelper.serverError(res, '获取服务分类失败', err);
  }
});

// 搜索本地服务 (可选身份验证)
router.get('/search', (req, res, next) => {
  // 尝试进行身份验证，但不强制要求
  const authHeader = req.headers.authorization;
  if (authHeader && authHeader.startsWith('Bearer ')) {
    authenticateToken(req, res, next);
  } else {
    next();
  }
}, async (req, res) => {
  try {
    const {
      category_id,
      province,
      city,
      page = 1,
      limit = 10,
      keyword
    } = req.query;

    const searchParams = {
      category_id,
      province,
      city,
      page: parseInt(page),
      limit: parseInt(limit),
      keyword
    };

    const result = await LocalServicePrisma.search(searchParams);
    
    // 如果用户已登录，检查点赞状态
    const servicesWithLikeStatus = await Promise.all(
      result.services.map(async (service) => {
        const serviceData = service.toJSON();
        if (req.user && req.user.id) {
          serviceData.is_liked = await LocalServicePrisma.checkUserLiked(service.id, req.user.id);
        } else {
          serviceData.is_liked = false;
        }
        return serviceData;
      })
    );
    
    return ResponseHelper.success(res, {
      items: servicesWithLikeStatus,
      total: result.total,
      page: parseInt(page),
      limit: parseInt(limit)
    }, '搜索服务成功');
  } catch (err) {
    console.error('搜索服务失败:', err);
    return ResponseHelper.serverError(res, '搜索服务失败', err);
  }
});

// 获取服务详情（可选身份验证）
router.get('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const service = await LocalServicePrisma.findById(id, {
      includeUser: true,
      includeCategory: true
    });

    if (!service) {
      return ResponseHelper.notFound(res, '服务不存在');
    }

    // 增加浏览次数
    await service.incrementViewCount();

    // 尝试解析用户认证信息
    let userId = null;
    const authHeader = req.headers.authorization;
    if (authHeader && authHeader.startsWith('Bearer ')) {
      try {
        const jwt = require('jsonwebtoken');
        const token = authHeader.substring(7);
        const decoded = jwt.verify(token, process.env.JWT_SECRET || 'your-secret-key');
        userId = decoded.id;
      } catch (error) {
        console.log('Token解析失败:', error.message);
        // 忽略token错误，继续执行
      }
    }

    // 检查点赞状态
    const serviceData = service.toJSON();
    if (userId) {
      serviceData.is_liked = await LocalServicePrisma.checkUserLiked(id, userId);
    } else {
      serviceData.is_liked = false;
    }

    return ResponseHelper.success(res, serviceData, '获取服务详情成功');
  } catch (err) {
    console.error('获取服务详情失败:', err);
    return ResponseHelper.serverError(res, '获取服务详情失败', err);
  }
});

// 创建新服务
router.post('/', authenticateToken, async (req, res) => {
  try {
    const {
      category_id,
      title,
      province,
      city,
      basic_services,
      extended_services,
      after_sale_service,
      contact_info,
      images,
      deposit_required
    } = req.body;

    // 验证必填字段
    if (!category_id || !title || !province || !city) {
      return ResponseHelper.error(res, '请填写完整的服务信息', 400);
    }

    // 验证分类是否存在
    const category = await ServiceCategoryPrisma.findById(category_id);
    if (!category) {
      return ResponseHelper.error(res, '服务分类不存在', 400);
    }

    // 检查用户本地服务发布信用
    try {
      await UserPrisma.reduceLocalServiceCredits(req.user.id, 1);
    } catch (creditError) {
      if (creditError.message === '本地服务发布信用不足') {
        return ResponseHelper.error(res, '本地服务发布信用不足，请先购买套餐', 400);
      }
      throw creditError;
    }

    // 设置30分钟后自动上架
    const autoPublishTime = new Date();
    autoPublishTime.setMinutes(autoPublishTime.getMinutes() + 30);

    const serviceData = {
      user_id: req.user.id,
      category_id,
      title,
      province,
      city,
      basic_services,
      extended_services,
      after_sale_service,
      contact_info,
      images,
      deposit_required: deposit_required || 0,
      auto_publish_at: autoPublishTime
    };

    const service = await LocalServicePrisma.create(serviceData);

    return ResponseHelper.success(res, service.toJSON(), '创建服务成功，将在30分钟后自动上架');
  } catch (err) {
    console.error('创建服务失败:', err);
    return ResponseHelper.serverError(res, '创建服务失败', err);
  }
});

// 更新服务
router.put('/:id', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const service = await LocalServicePrisma.findById(id);

    if (!service) {
      return ResponseHelper.notFound(res, '服务不存在');
    }

    // 检查权限：只有服务创建者可以编辑
    if (service.user_id.toString() !== req.user.id.toString()) {
      return ResponseHelper.forbidden(res, '无权限编辑此服务');
    }

    const updatedService = await service.update(req.body);
    return ResponseHelper.success(res, updatedService.toJSON(), '更新服务成功');
  } catch (err) {
    console.error('更新服务失败:', err);
    return ResponseHelper.serverError(res, '更新服务失败', err);
  }
});


// 重新提交审核
router.post('/:id/resubmit-audit', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const service = await LocalServicePrisma.findById(id);

    if (!service) {
      return ResponseHelper.notFound(res, '服务不存在');
    }

    // 检查权限
    if (service.user_id.toString() !== req.user.id.toString()) {
      return ResponseHelper.forbidden(res, '无权限操作此服务');
    }

    // 只有被拒绝的服务可以重新提交审核
    if (service.audit_status !== 'REJECTED') {
      return ResponseHelper.error(res, '只有被拒绝的服务可以重新提交审核', 400);
    }

    // 重置审核状态，等待管理员手动审核（不设置自动发布时间）
    await service.update({
      audit_status: 'PENDING',
      audit_comment: null,
      audit_time: null,
      auto_publish_at: null // 不设置自动发布，需要管理员手动审核
    });

    return ResponseHelper.success(res, service.toJSON(), '已重新提交审核，等待管理员审核');
  } catch (err) {
    console.error('重新提交审核失败:', err);
    return ResponseHelper.serverError(res, '重新提交审核失败', err);
  }
});

// 下架服务
router.post('/:id/offline', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const service = await LocalServicePrisma.findById(id);

    if (!service) {
      return ResponseHelper.notFound(res, '服务不存在');
    }

    // 检查权限
    if (service.user_id.toString() !== req.user.id.toString()) {
      return ResponseHelper.forbidden(res, '无权限操作此服务');
    }

    const updatedService = await service.offline();
    return ResponseHelper.success(res, updatedService.toJSON(), '服务已下架');
  } catch (err) {
    console.error('下架服务失败:', err);
    return ResponseHelper.serverError(res, '下架服务失败', err);
  }
});

// 重新上架服务
router.post('/:id/republish', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const service = await LocalServicePrisma.findById(id);

    if (!service) {
      return ResponseHelper.notFound(res, '服务不存在');
    }

    // 检查权限
    if (service.user_id.toString() !== req.user.id.toString()) {
      return ResponseHelper.forbidden(res, '无权限操作此服务');
    }

    // 只有下架状态的服务可以重新上架
    if (service.status !== 'OFFLINE') {
      return ResponseHelper.error(res, '只有已下架的服务可以重新上架', 400);
    }

    // 检查保证金
    if (!service.hasEnoughDeposit()) {
      return ResponseHelper.error(res, `请先支付足够的保证金（需要：${service.deposit_required}元，已付：${service.deposit_paid}元）`, 400);
    }

    // 设置30分钟后自动上架
    const autoPublishTime = new Date();
    autoPublishTime.setMinutes(autoPublishTime.getMinutes() + 30);

    // 更新状态为草稿状态，等待自动发布
    await service.update({ 
      status: 'DRAFT', 
      audit_status: 'PENDING',
      auto_publish_at: autoPublishTime
    });

    return ResponseHelper.success(res, service.toJSON(), '服务已重新提交，将在30分钟后自动上架');
  } catch (err) {
    console.error('重新上架服务失败:', err);
    return ResponseHelper.serverError(res, '重新上架服务失败', err);
  }
});

// 获取用户的服务列表
router.get('/user/my-services', authenticateToken, async (req, res) => {
  try {
    const {
      page = 1,
      limit = 10,
      status,
      audit_status
    } = req.query;

    const options = {
      page: parseInt(page),
      limit: parseInt(limit),
      status,
      audit_status
    };

    const result = await LocalServicePrisma.findByUserId(req.user.id, options);

    return ResponseHelper.success(res, {
      items: result.services.map(service => service.toJSON()),
      total: result.total,
      page: parseInt(page),
      limit: parseInt(limit)
    }, '获取服务列表成功');
  } catch (err) {
    console.error('获取服务列表失败:', err);
    return ResponseHelper.serverError(res, '获取服务列表失败', err);
  }
});

// 删除服务（硬删除，从数据库中完全删除）
router.delete('/:id', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const service = await LocalServicePrisma.findById(id);

    if (!service) {
      return ResponseHelper.notFound(res, '服务不存在');
    }

    // 检查权限
    if (service.user_id.toString() !== req.user.id.toString()) {
      return ResponseHelper.forbidden(res, '无权限删除此服务');
    }

    // 只有草稿和下架状态的服务可以删除
    if (service.status !== 'DRAFT' && service.status !== 'OFFLINE') {
      return ResponseHelper.error(res, '只有草稿和下架状态的服务可以删除', 400);
    }

    // 硬删除：从数据库中完全删除
    await service.hardDelete();
    return ResponseHelper.success(res, null, '删除服务成功');
  } catch (err) {
    console.error('删除服务失败:', err);
    return ResponseHelper.serverError(res, '删除服务失败', err);
  }
});

// 点赞/取消点赞服务
router.post('/:id/like', authenticateToken, async (req, res) => {
  try {
    const serviceId = req.params.id;
    const userId = req.user.id;

    const service = await LocalServicePrisma.findById(serviceId);
    if (!service) {
      return ResponseHelper.notFound(res, '服务不存在');
    }

    const result = await LocalServicePrisma.toggleLike(serviceId, userId);
    return ResponseHelper.success(res, result, result.liked ? '点赞成功' : '取消点赞成功');
  } catch (err) {
    console.error('点赞操作失败:', err);
    return ResponseHelper.serverError(res, '点赞操作失败', err);
  }
});

// 发表评论
router.post('/:id/comments', authenticateToken, async (req, res) => {
  try {
    const serviceId = req.params.id;
    const userId = req.user.id;
    const { content } = req.body;

    if (!content || content.trim().length === 0) {
      return ResponseHelper.error(res, '评论内容不能为空', 400);
    }

    if (content.length > 500) {
      return ResponseHelper.error(res, '评论内容不能超过500字', 400);
    }

    const service = await LocalServicePrisma.findById(serviceId);
    if (!service) {
      return ResponseHelper.notFound(res, '服务不存在');
    }

    const comment = await LocalServicePrisma.createComment({
      service_id: serviceId,
      user_id: userId,
      content: content.trim()
    });

    return ResponseHelper.success(res, { comment }, '评论发表成功');
  } catch (err) {
    console.error('发表评论失败:', err);
    return ResponseHelper.serverError(res, '发表评论失败', err);
  }
});

// 获取服务评论列表
router.get('/:id/comments', async (req, res) => {
  try {
    const serviceId = req.params.id;
    const page = parseInt(req.query.page) || 1;
    const pageSize = Math.min(parseInt(req.query.pageSize) || 20, 50);

    const result = await LocalServicePrisma.getCommentsByServiceId(serviceId, page, pageSize);
    return ResponseHelper.success(res, result, '获取评论列表成功');
  } catch (err) {
    console.error('获取评论列表失败:', err);
    return ResponseHelper.serverError(res, '获取评论列表失败', err);
  }
});

// ==================== 数据修复相关API ====================

// 获取数据一致性报告
router.get('/admin/consistency-report', authenticateToken, async (req, res) => {
  try {
    // 简单验证是否为管理员（可以根据实际需求调整）
    // 这里假设管理员具有特殊权限标识
    const report = await LocalServicePrisma.getConsistencyReport();
    return ResponseHelper.success(res, report, '获取数据一致性报告成功');
  } catch (err) {
    console.error('获取数据一致性报告失败:', err);
    return ResponseHelper.serverError(res, '获取数据一致性报告失败', err);
  }
});

// 修复所有服务的计数数据
router.post('/admin/fix-counts', authenticateToken, async (req, res) => {
  try {
    // 简单验证是否为管理员（可以根据实际需求调整）
    console.log('开始修复本地服务计数数据...');
    
    const result = await LocalServicePrisma.fixAllCounts();
    
    console.log(`修复完成: ${result.fixed} 个服务被修复`);
    console.log('一致性状态:', result.stats.is_consistent ? '一致' : '不一致');
    
    return ResponseHelper.success(res, result, `修复完成，共修复了 ${result.fixed} 个服务的计数数据`);
  } catch (err) {
    console.error('修复计数数据失败:', err);
    return ResponseHelper.serverError(res, '修复计数数据失败', err);
  }
});

module.exports = router;